package com.estore.service;

import com.estore.model.Product;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.io.*; // 添加IO导入
import java.util.concurrent.ConcurrentHashMap;


/**
 * 商品服务类，负责商品相关的业务逻辑
 * 目前使用内存Map模拟数据库
 */
public class ProductService {
    private static final String DATA_FILE = "products.dat"; // 添加数据文件路径

    // 使用Map存储商品数据，key是商品ID，value是商品对象
    // 优点：通过ID查找商品时，时间复杂度是O(1)，非常高效
    private final Map<String, Product> productData = new ConcurrentHashMap<>();


    /**
     * 构造函数，初始化一些商品数据
     */
    public ProductService() {
        loadData(); // 在构造函数中加载数据

        // 如果没有加载到数据，则初始化默认数据
        if (productData.isEmpty()) {
            initializeDefaultData();
        }
    }

    /**
     * 初始化默认商品数据
     */
    private void initializeDefaultData() {
        // 为Java书籍添加标签
        Set<String> tagsForJavaBook = new HashSet<>();
        tagsForJavaBook.add("编程");
        tagsForJavaBook.add("畅销");
        // 验证Set的唯一性 - 添加重复标签
        tagsForJavaBook.add("热门");
        tagsForJavaBook.add("热门"); // 重复添加，但Set会自动去重
        productData.put("p001", new Product("p001", "Java从入门到精通", 99.0, 100, tagsForJavaBook));

        // 为MySQL书籍添加标签
        Set<String> tagsForMySQLBook = new HashSet<>();
        tagsForMySQLBook.add("数据库");
        tagsForMySQLBook.add("技术");
        productData.put("p002", new Product("p002", "高性能MySQL", 128.5, 50, tagsForMySQLBook));

        // 为颈椎康复指南添加标签
        Set<String> tagsForHealthBook = new HashSet<>();
        tagsForHealthBook.add("健康");
        tagsForHealthBook.add("医疗");
        productData.put("p003", new Product("p003", "颈椎康复指南", 45.0, 200, tagsForHealthBook));

        // 库存为0的商品，不添加标签
        productData.put("p004", new Product("p004", "生发秘籍", 88.0, 0));

        // 其他商品保持不变
        Set<String> tagsForCBook = new HashSet<>();
        tagsForCBook.add("编程");
        tagsForCBook.add("热门");
        productData.put("p005", new Product("p005", "java从入门到精通", 69.0, 88, tagsForCBook));
        productData.put("p006", new Product("p006", "python从入门到精通", 69.0, 66));
        productData.put("p007", new Product("p007", "C++从入门到精通", 69.0, 55));
    }

 /**
 * 保存商品数据到文件
 */
public void saveData() {
    try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(DATA_FILE))) {
        oos.writeObject(productData);
        System.out.printf("商品数据已保存到 %s%n", DATA_FILE);
    } catch (IOException e) {
        System.err.printf("保存商品数据时出错: %s%n", e.getMessage());
    }
}


/**
 * 从文件加载商品数据
 */
@SuppressWarnings("unchecked")
private void loadData() {
    try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(DATA_FILE))) {
        Map<String, Product> loadedData = (Map<String, Product>) ois.readObject();
        productData.clear();
        productData.putAll(loadedData);
        System.out.printf("商品数据已从 %s 加载%n", DATA_FILE);

        // 验证标签数据是否正确加载
        for (Map.Entry<String, Product> entry : productData.entrySet()) {
            Product product = entry.getValue();
            if (product.getTags() != null) {
                System.out.printf("商品 %s 加载标签: %s%n", product.getId(), product.getTags());
            }
        }
    } catch (FileNotFoundException e) {
        System.out.printf("未找到商品数据文件 %s，将创建新的数据文件。%n", DATA_FILE);
    } catch (IOException | ClassNotFoundException e) {
        System.err.printf("加载商品数据时出错: %s%n", e.getMessage());
    }
}
/**
 * 检查商品库存是否足够
 * @param productId 商品ID
 * @param quantity 需要的数量
 * @return 库存是否足够
 */
public boolean hasEnoughStock(String productId, int quantity) {
    Product product = productData.get(productId);
    return product != null && product.getStock() >= quantity;
}

/**
 * 减少商品库存
 * @param productId 商品ID
 * @param quantity 要减少的数量
 * @return 是否成功减少库存
 */
public boolean reduceStock(String productId, int quantity) {
    Product product = productData.get(productId);
    if (product != null && product.getStock() >= quantity) {
        product.setStock(product.getStock() - quantity);
        saveData(); // 保存数据
        return true;
    }
    return false;
}

    /**
     * 获取所有商品列表
     * @return 商品列表
     */
    public List<Product> getAllProducts() {
        // 从Map的值集合创建一个新的ArrayList并返回
        return new ArrayList<>(productData.values());
    }
// 需要在 ProductService 中添加此方法
// 在 ProductService 类中添加或完善 updateStock 方法
// 在 ProductService.java 中添加以下方法
/**
 * 更新商品价格
 * @param productId 商品ID
 * @param newPrice 新价格
 * @return 更新后的商品对象，如果商品不存在则返回null
 */
public Product updatePrice(String productId, double newPrice) {
    if (newPrice < 0) {
        System.out.println("价格不能为负数");
        return null;
    }

    Product product = productData.get(productId);
    if (product != null) {
        product.setPrice(newPrice);
        return product;
    }
    System.out.printf("未找到ID为 %s 的商品%n", productId);
    return null;
}

/**
 * 更新商品名称
 * @param productId 商品ID
 * @param newName 新名称
 * @return 更新后的商品对象，如果商品不存在则返回null
 */
public Product updateName(String productId, String newName) {
    if (newName == null || newName.trim().isEmpty()) {
        System.out.println("商品名称不能为空");
        return null;
    }

    Product product = productData.get(productId);
    if (product != null) {
        product.setName(newName);
        return product;
    }
    System.out.printf("未找到ID为 %s 的商品%n", productId);
    return null;
}
// 在 ProductService 类中添加或完善 updateStock 方法
/**
 * 更新商品库存
 * @param productId 商品ID
 * @param newStock 新库存数量
 * @return 更新后的商品对象，如果商品不存在则返回null
 */
public Product updateStock(String productId, int newStock) {
    // 设置合理的库存上限，防止异常数据
    final int MAX_STOCK = 99999;

    if (newStock < 0) {
        System.out.println("库存不能为负数");
        return null;
    }

    if (newStock > MAX_STOCK) {
        System.out.printf("库存不能超过最大限制: %d%n", MAX_STOCK);
        return null;
    }

    Product product = productData.get(productId);
    if (product != null) {
        product.setStock(newStock);
        return product;
    }
    System.out.printf("未找到ID为 %s 的商品%n", productId);
    return null;
}

/**
 * 更新商品ID
 * @param oldId 原商品ID
 * @param newId 新商品ID
 * @return 更新后的商品对象，如果原商品不存在或新ID已存在则返回null
 */
public Product updateId(String oldId, String newId) {
    if (newId == null || newId.trim().isEmpty()) {
        System.out.println("商品ID不能为空");
        return null;
    }

    if (productData.containsKey(newId)) {
        System.out.printf("ID为 %s 的商品已存在%n", newId);
        return null;
    }

    Product product = productData.get(oldId);
    if (product != null) {
        productData.remove(oldId);
        product.setId(newId);
        productData.put(newId, product);
        return product;
    }
    System.out.printf("未找到ID为 %s 的商品%n", oldId);
    return null;
}
/**
 * 更新商品标签
 * @param productId 商品ID
 * @param tags 新的标签集合
 * @return 更新后的商品对象，如果商品不存在则返回null
 */
public Product updateTags(String productId, Set<String> tags) {
    // 参数验证
    if (productId == null || productId.trim().isEmpty()) {
        System.out.println("商品ID不能为空");
        return null;
    }

    Product product = productData.get(productId);
    if (product != null) {
        // 处理标签集合，确保不为null且清理空白标签
        Set<String> cleanTags = new HashSet<>();
        if (tags != null) {
            for (String tag : tags) {
                if (tag != null && !tag.trim().isEmpty()) {
                    cleanTags.add(tag.trim());
                }
            }
        }
        product.setTags(cleanTags);
        saveData(); // 添加数据持久化
        System.out.printf("成功更新商品 %s 的标签%n", productId);
        return product;
    }
    System.out.printf("未找到ID为 %s 的商品%n", productId);
    return null;
}


public boolean addTagToProduct(String productId, String tag) {
    // 参数验证
    if (productId == null || productId.trim().isEmpty()) {
        System.out.println("商品ID不能为空");
        return false;
    }

    if (tag == null || tag.trim().isEmpty()) {
        System.out.println("标签不能为空");
        return false;
    }

    Product product = productData.get(productId);
    if (product != null) {
        // 确保 tags 集合不为 null
        if (product.getTags() == null) {
            product.setTags(new HashSet<>());
        }

        // 添加标签（先清理标签字符串）
        String trimmedTag = tag.trim();
        boolean added = product.getTags().add(trimmedTag);

        if (added) {
            saveData(); // 确保数据持久化
            System.out.printf("成功为商品 %s 添加标签: %s%n", productId, trimmedTag);
        } else {
            System.out.printf("标签 %s 已存在于商品 %s 中%n", trimmedTag, productId);
        }
        return added;
    }
    System.out.printf("未找到ID为 %s 的商品%n", productId);
    return false;
}


  /**
 * 从商品中移除指定标签
 * @param productId 商品ID
 * @param tag 要移除的标签
 * @return 如果成功移除标签返回true，否则返回false
 */
public boolean removeTagFromProduct(String productId, String tag) {
    // 参数验证
    if (productId == null || productId.trim().isEmpty()) {
        System.out.println("商品ID不能为空");
        return false;
    }

    if (tag == null || tag.trim().isEmpty()) {
        System.out.println("标签不能为空");
        return false;
    }

    // 查找商品
    Product product = productData.get(productId);
    if (product == null) {
        System.out.printf("未找到ID为 %s 的商品%n", productId);
        return false;
    }

    // 确保 tags 集合不为 null
    if (product.getTags() == null) {
        System.out.printf("商品 %s 没有标签可移除%n", productId);
        return false;
    }

    // 移除标签（先清理标签字符串）
    String trimmedTag = tag.trim();
    boolean removed = product.getTags().remove(trimmedTag);

    if (removed) {
        // 成功移除后保存数据
        saveData();
        System.out.printf("成功从商品 %s 中移除标签: %s%n", productId, trimmedTag);
    } else {
        System.out.printf("商品 %s 中未找到标签: %s%n", productId, trimmedTag);
    }

    return removed;
}

    /**
     * 根据ID查找商品
     * @param id 商品ID
     * @return 找到的商品对象，如果不存在则返回null
     */
    public Product findProductById(String id) {
        return productData.get(id);
    }
}
